Secure communication session resumption in a service function chain

ABSTRACT

A method for resuming a Transport Layer Security (TLS) session in a Service Function Chain comprising a plurality of Service Function nodes coupled to a Service Function Forwarder. A request is received at a first Service Function node to establish a TLS session, and a Pre-Shared Key (PSK) and a PSK identifier that uniquely correspond to the first Service Function node and the TLS session are generated. The PSK identifier is forwarded to one or more of the Service Function Forwarder and the plurality of Service Function nodes. A request to resume the TLS session is received from a client device that previously disconnected. It is determined that the connection request contains the PSK identifier, a second Service Function node is selected, and the TLS session is re-established between the client device and the second Service Function node using the same PSK as the prior TLS session.

TECHNICAL FIELD

The present technology relates generally to secure communication sessions, and more specifically relates to the resumption of Transport Layer Security (TLS) sessions without performing a full TLS handshake.

BACKGROUND

In a session between an endpoint client and an endpoint server secured with the Transport Layer Security (TLS) protocol, one or more Service Function (SF) nodes may act upon the traffic in the session to provide a service function (e.g. firewall, intrusion detection/prevention, traffic compression, etc.). The Service Function node will typically interpose itself into the secure TLS session and create two separate TLS session by acting as a proxy server for the endpoint client and acting as a proxy client for the endpoint server. The TLS session between the endpoint client and the Service Function node is associated with a unique set of cryptographic keys, generated during a TLS handshake. In some embodiments, multiple Service Function nodes can be interposed into the secure TLS session, creating a Service Function Chain (SFC).

If the endpoint client disconnects from the TLS session, it may still retain a copy of the unique set of cryptographic keys. In order to resume the TLS session, the endpoint client must reconnect to the same Service Function node and provide its copy of the unique set of cryptographic keys. In this manner, a full TLS handshake is avoided. If the endpoint client attempts to present its copy of the unique set of cryptographic keys to a different Service Function node, the connection request will be a rejected and a new full TLS handshake will have to be performed.

When no Service Function Chain is present, the endpoint client may be able to easily reconnect to the same Service Function node from the previous TLS session. However, when a Service Function Chain is present, endpoint client communications typically pass first through a Service Function Forwarder (SFF), which performs load balancing in order to determine where to forward an endpoint client communication. Even if the endpoint client presents its copy of the unique set of cryptographic keys, the Service Function node that generated these keys is unknown to the Service Function Forwarder, due to the inherent encryption associated with the TLS protocol. As such, it would be highly desirable to provide an improved method for TLS session resumption, such that a session resume request does not trigger a new TLS handshake, regardless of whether the session resume request is forwarded to the originating Service Function node or a new Service Function node.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which the above-recited and other advantages and features of the disclosure can be obtained, a more particular description of the principles briefly described above will be rendered by reference to specific examples thereof which are illustrated in the appended drawings. Understanding that these drawings depict only examples of the disclosure and are not therefore to be considered to be limiting of its scope, the principles herein are described and explained with additional specificity and detail through the use of the accompanying drawings in which:

FIG. 1 depicts a diagram of a network system in which embodiments of the present disclosure may operate;

FIG. 2 depicts a ladder diagram of the underlying message exchanged involved in a TLS handshake;

FIG. 3 depicts a ladder diagram of the underlying message exchange of an example embodiment of the present disclosure wherein a Service Function Forwarder forwards a TLS session resume request to the Service Function node that previously handled the session;

FIG. 4 depicts a ladder diagram of the underlying message exchange of an example embodiment of the present disclosure wherein a TLS session is resumed at a new Service Function node;

FIG. 5 depicts a ladder diagram of the underlying message exchange of an example embodiment of the present disclosure wherein an encrypted Pre-Shared Key is included in a TLS session resume request.

FIG. 6A depicts a conventional system bus computing system architecture;

FIG. 6B depicts an example computer system having a chipset architecture.

DESCRIPTION OF EXAMPLE EMBODIMENTS

The detailed description set forth below is intended as a description of various configurations of the subject technology and is not intended to represent the only configurations in which the subject technology can be practiced. The appended drawings are incorporated herein and constitute a part of the detailed description. The detailed description includes specific details for the purpose of providing a more thorough understanding of the subject technology. However, it will be clear and apparent that the subject technology is not limited to the specific details set forth herein and may be practiced without these details. In some instances, structures and components are shown in block diagram form in order to avoid obscuring the concepts of the subject technology.

Overview

Transport Layer Security, or TLS, is a cryptographic protocol used to provide secured communications between two computing devices, such as a client and a server. First standardized in 1999 as TLS 1.0, the TLS protocol has continued to be developed and updated in order to keep pace with the ever-increasing importance of security and encryption in the modern world. The previous version, TLS 1.2, has been subject to an increasing number of attacks, and the most recent version, TLS 1.3, was introduced in order to address these flaws and provide an overall enhanced security experience.

In order to establish a TLS session between a client and a server, a TLS handshake is performed in order to establish shared cryptographic keys. These shared cryptographic keys are typically uniquely associated with both the TLS session and the client/server devices themselves. As such, if a client wishes to resume a TLS session, the original cryptographic keys can be used to identify the originating server and forward the client resume request accordingly. The original cryptographic keys can then be used to resume the TLS session without having to perform a TLS handshake, reducing latency and increasing efficiency.

TLS 1.2 utilized a clear text message exchange for the TLS handshake, which allowed client resume requests to be easily forwarded to the proper originating server. However, TLS 1.3 now encrypts all TLS handshake messages except for the initial ClientHello, meaning that the association between a client resume request and the originating server is now opaque to other networked devices or forwarders, such as load balancers.

For example, consider a Service Function Forwarder (SFF) acting as a load balancer for various Service Function nodes (e.g. firewalls, intrusion detection/prevention, traffic compression etc.) acting as TLS proxies/servers. Under TLS 1.2, the SFF would receive a client resume request, consult previously observed clear text TLS handshake messages, and identify the originating server and forward the client resume request accordingly. Under TLS 1.3, the SFF would receive a client resume request and would be unable to identify the originating server, due to the encryption of the TLS handshake messages. At best, the SFF could perform normal load balancing, and the client resume request may coincidentally be forwarded to the originating server. However, it is far more likely that the client resume request will not be forwarded to the originating server, and will be forced to perform a new TLS handshake with the new server.

As such, current implementations of TLS 1.3 are often inefficient in terms of both time and computational resources due to new TLS handshakes being forced in response to improperly forwarded client resume requests. Further still, TLS 1.3 breaks many other networking techniques that relied upon the proper forwarding of client resume requests to their originating servers. For example, if a new TLS handshake does not have to be performed, a zero round trip mode (0-RTT) can be employed, where the client resume request contains an initial flight of data for the server to act upon.

Example Embodiments

FIG. 1 illustrates a simplified diagram of a network system 100 in which aspects of the present disclosure may operate. Network system 100 includes an endpoint client device 102 (also referred to as “client” or “client device”) and an endpoint server device 112 (also referred to as “server” or “server device”). Client 102 and server 112 can communicate secure messages to one another by establishing an encrypted TLS session, using, for example, version 1.3 of the TLS protocol, although it is understood that other versions of the TLS protocol may also be employed.

Interposed between client 102 and server 112 is a Service Function Group 120, comprising a Service Function Forwarder (SFF) 122 communicatively coupled to a plurality of Service Function (SF) nodes 124 a-c. In some embodiments, SFF 122 can operate as a load balancer, forwarding traffic from client 102 (or other connected client devices, not shown) to an appropriate or otherwise selected SF node 124 a-c.

While three SF nodes are illustrated, it is understood that the plurality of SF nodes can include a greater or lesser number of. In general, each of the plurality of SF nodes 124 a-c can provide various service functions to traffic passing through the Service Function Group 120. For example, such traffic might include the secure messages transmitted between client 102 and server 112. The various service functions can include, but are not limited to, firewalls, distributed denial of service (DDOS) protection, intrusion detection/prevention service (IDS/IPS), traffic optimizers, compression services, advertisement insertion, etc. A given one of the plurality of SF nodes 124 a-c may be configured to provide one or more specific service functions, or may be configured to provide all of the service functions offered by Service Function Group 120.

In some embodiments, two or more of the plurality of SF nodes 124 a-c may be provided on separate network devices or computing devices. In some embodiments, one or more of the SF nodes 124 a-c may be provided by a single network device or computing device. Furthermore, the plurality of SF nodes 124 a-c may operate on a single communications network, or may operate on a plurality of interconnected communication networks. As would be appreciated by one of ordinary skill in the art, additional modifications to the manner in which Service Function Group 120 distributes and manages the various service functions may be employed without departing from the scope of the present disclosure.

For purposes of clarity of explanation, the following description contemplates a scenario in which SF nodes 124 a-c each provide a dedicated service function. Although only client device 102 is illustrated, additional client devices may simultaneously connect to Service Function Forwarder 122, and correspondingly, each of the SF nodes 124 a-c may provide a dedicated service function to traffic originating from one or more client devices.

A Service Function Chain (SFC) is formed when two or more service functions are connected. For example, an SFC could be formed between SF node 124 a and SF node 124 b, wherein SF node 124 a might be a firewall and SF node 124 b might be a compression service. In this scenario, Service Function Forwarder receives a message stream from client 102, and forwards the message stream to the firewall of SF node 124 a. SF node 124 a performs firewall filtering, and then forwards the filtered message stream to the compression service of SF node 124 b. SF node 124 b performs compression, and forwards the compressed message stream to server 112.

In some embodiments, when the TLS protocol is employed to encrypt traffic and message streams, each SF node in the Service Function Chain acts as a TLS proxy or server. In other words, each hop of a message stream between client 102 and server 112 requires its own TLS session, with the exception of Service Function Forwarder 122. Recalling that any given TLS session generates cryptographic keys uniquely corresponding to the two endpoints involved in the given TLS session, consider the context of the current example, wherein client 102 wishes to establish an encrypted TLS session with server 112.

A first proxy TLS session is established between client 102 and SF node 124 a, with SF node 124 a acting as a proxy server. A second proxy TLS session is established between SF node 124 a and SF node 124 b, with SF node 124 a acting as a proxy client and SF node 124 b acting as a proxy server. A third proxy TLS session is established between SF node 124 b and server 112, with SF node 124 b acting as a proxy client. Three hops are required to transmit a message stream between client 102 and server 112, and a corresponding three TLS sessions (and three sets of cryptographic keys) are generated.

Notably, client 102 is only directly involved in the very first TLS session, i.e. the TLS session connecting client 102 to the first SF node 124 a of the Service Function Chain, meaning that client 102 also only exchanges TLS cryptographic keys with SF node 124 a, even though the message stream from client 102 also passes through SF node 124 b. As such, client 102 and SF node 124 b are generally unaware of each other's presence in the communication path. Consequently, session resumption (which requires presenting a copy of the previously generated TLS cryptographic keys to the same SF node that generated said keys) becomes problematic if the session resumption request is directed anywhere but SF node 124 a—a problem which is addressed by various aspects of the present disclosure.

The disclosure now turns to FIG. 2, which depicts a ladder diagram 200 of the underlying message exchange involved in a TLS handshake for the creation of the first TLS session between client 102 and SF node 124 a, and the subsequent resumption of the TLS session. Client 102 begins by generating a ClientHello message 202, in accordance with the TLS protocol, which can contain cryptographic keying material or various cryptographic parameters for establishing cryptographic keying material. As discussed previously, while ClientHello message 202 may ultimately be destined for server 112 (not pictured), it is intercepted by Service Function Forwarder 122, which performs load balancing and forwards the ClientHello to an appropriate or otherwise selected Service Function node. In this example, Service Function Forwarder 122 forwards the ClientHello message 202 to SF node 124 a.

SF node 124 a receives and processes the ClientHello 202, determining the appropriate cryptographic parameters for the TLS session and generating a ServerHello message 204, which is transmitted to client 102 in order to convey the negotiated connection parameters. The ServerHello can contain cryptographic keying material and various other server parameters for establishing the TLS session. In accordance with the TLS protocol, the combination of the ClientHello message 202 and the ServerHello message 204 determines the shared keys that are used to secure and encrypt the TLS session. In some embodiments, Pre-Shared Key (PSK) key establishment can be employed, in which case the ClientHello 202 will contain several offered keys (i.e. PSKs) and the ServerHello 204 will contain an extension indicating which of the PSKs offered by client 102 was selected.

In order to finalize the establishment of the TLS session between client 102 and SF node 124 a, client 102 receives and process ServerHello 204 before then transmitting a Finished message 206 to SF node 124 a. The Finished message 206 is the final message in the authentication block, and is a Message Authentication Code (MAC) over the entire TLS handshake, which provides key confirmation and binds the identity of client 102 and SF node 124 a to the selected keys. In PSK mode, Finished message 206 also authenticates the TLS handshake.

At this point, the TLS handshake is complete, and the first TLS session has been established between client 102 and SF node 124 a. With the TLS session established, application-layer data can be exchanged, and is encrypted using the cryptographic keys determined from ClientHello 202 and ServerHello 204. Because this is a new TLS session, client 102 will not send application data prior to sending Finished message 206.

At some subsequent point in time, after Finished message 206 has been transmitted but before the TLS session is terminated, SF node 124 a can transmit a NewSessionTicket 208 to client 102. This message creates a pre-shared key (PSK) binding between the ticket value of NewSessionTicket 208 and the resumption master secret. In other words, the client 102 can re-use the cryptographic key previously established in the first TLS session with SF node 124 a to then resume the TLS session with SF node 124 a at some later point in time, without having to perform another full TLS handshake. To do so, client 102 would include the ticket value of NewSessionTicket 208 in the “pre_shared_key” extension in its ClientHello message.

However, as mentioned previously, such a ClientHello, containing a PSK for TLS session resumption, must be directed to the same SF node that originated the PSK in the previous TLS session. In the context of the present example, a TLS session resumption request from client 102 would have to be forwarded to SF node 124 a in order for the TLS session to be resumed without a new TLS handshake and key generation. However, in general, Service Function Forwarder 122 is unable to identify the SF node that generated a given PSK contained within a ClientHello message, due to various limitations of the TLS protocol.

Accordingly, FIG. 3 depicts a ladder diagram 300 of the underlying message exchange of an example embodiment of the present disclosure, designed to permit Service Function Forwarder 122 to correctly identify the SF node that generated a given PSK contained within a resume ClientHello message. As illustrated, a TLS session is established between client 102 and SF node 124 a in a manner consistent with the above description of FIG. 2. However, after the TLS session has been established, SF node 124 a is configured to further transmit a PSK identifier 310 to at least Service Function Forwarder 122. In some embodiments, a corresponding ticket lifetime may additionally be transmitted along with PSK identifier 310. In some embodiments, the transmission of PSK identifier 310 (and any corresponding ticket lifetime) may also be extended to include additional SF nodes of the same Service Function Group (i.e. SF nodes 124 b and 124 c of Service Function Group 120).

Upon receipt of PSK identifier 310, Service Function Forwarder 122 (and any SF nodes also receiving the PSK identifier) can construct a database or otherwise store in memory the association between the PSK identifier 310 and the originating SF node 124 a. In some embodiments, the Service Function Forwarder 122 and the SF nodes may each construct a local memory structure for storing the PSK identifier 310. In some embodiments, a single centralized memory structure can be generated for storing the PSK identifier 310, and can be accessed by the Service Function Forwarder 122 and the SF nodes 124 a-c as needed. In either embodiment, the memory structure can be stored in a conventional storage device (e.g. hard drive, solid state drive, etc.) or can be stored in RAM for faster access, and therefore, faster session resumption. Regardless of the specific configuration chosen for storing the PSK identifier 310, Service Function Forwarder 122 can access the memory structure to identify the appropriate originating SF node to forward a resume ClientHello message, as is described in greater detail below.

After PSK identifier 310 is transmitted to Service Function Forwarder 122 and any additional SF nodes, the TLS session between client 102 and SF node 124 a continues as normal, exchanging application data 312 before the eventual termination 314 of the TLS session. Note that after terminating the TLS session with SF node 124 a, client 102 still retains NewSessionTicket 208, which contains the PSK used in the TLS session and therefore allows session resumption without a new TLS handshake being required.

Thus, when client 102 desires to resume the TLS session, it generates a resume ClientHello message 316, which contains the ticket value of NewSessionTicket 208 in the “pre_shared_key” extension (i.e. the PSK identifier 310). Additionally, a zero round trip mode can be employed, wherein the ClientHello contains an initial flight of data or application data, encrypted using the PSK, such that the TLS session can be established and the initial flight of data immediately decrypted and acted upon, thereby increasing the speed and efficiency of the TLS session resumption.

The resume ClientHello message 316 is received at Service Function Forwarder 122, which parses the message to extract PSK identifier 310. Service Function Forwarder 122 may also extract and validate the corresponding ticket lifetime of PSK identifier 310 before proceeding. With the PSK identifier 310 extracted, Service Function Forwarder 122 then consults its database or memory structure to determine the specific SF node that is associated with PSK identifier 310, and therefore, is associated with the previous TLS session.

In this case, Service Function Forwarder 122 consults its database or memory structure and determines that the PSK identifier 310 contained within resume ClientHello message 316 was generated by SF node 124 a, and therefore forwards resume ClientHello message 316 to SF node 124 a. The TLS session then resumes using the same PSK that was used in the original TLS session between client 102 and SF node 124 a.

If, for some reason, Service Function Forwarder 122 makes an error or otherwise fails to forward resume ClientHello message 316 to SF node 124 a, the situation may still be resolved without resorting to a new TLS handshake. For example, if resume ClientHello message 316 is forwarded to SF node 124 b, SF node 124 b can extract the PSK identifier 310 and determine that the PSK identifier was generated by a different SF node. SF node 124 b can then consult its memory structure, whether local or centralized, to determine that SF node 124 a was the actual SF node that originated PSK identifier 310. On the basis of this determination, SF node 124 b can redirect the resume ClientHello message 316 to SF node 124 a, where the TLS session then resumes using the same PSK that was used in the original TLS session between client 102 and SF node 124 a.

Advantageously, the TLS session has been resumed with a single transmission from client 102, and, using the same PSK as in the previous TLS session, SF node 124 a is able to immediately act upon and decrypt any initial flight of data contained in resume ClientHello message 316. Accordingly, SF node 124 a then generates a ServerHello message 318, as described previously, which also further includes corresponding application data responsive to the initial flight of data contained within resume ClientHello message 316. With the TLS session resumed, it then proceeds as normal, with the transmission of a Finished message 320 from client 102 and a subsequent exchange of application data 322.

In some embodiments, the PSK identifier and other data transmitted amongst the plurality of Service Function nodes 124 a-c and the Service Function Forwarder 122 is shared using a publish-subscribe mechanism, as is known in the art. In such an embodiment, the SF node generating a NewSessionTicket and a new TLS session can be the publishing node. In some embodiments, the PSK identifier and other data transmitted amongst the plurality of Service Function nods 124 a-c and the Service Function Forwarder 122 is shared via encapsulation in Network Service Header (NSH) metadata. In particular, an NSH Metadata-Type 2 Type Length Value (NSH MD-Type 2 TLV) can be employed.

Furthermore, various transport protocols can be employed with any of the TLS sessions referenced herein. For example, transport protocols might include TCP (Transmission Control Protocol) and QUIC (Quick UDP Internet Connections). In some scenarios, TCP Fast Start may be employed in order to transmit an initial flight of zero round trip data in the ClientHello. In particular, TCP Fast Start allows the initial fight of data to be carried in SYN and SYN-ACK packets. In the context of the example of FIG. 3, if Service Function Forwarder 122 detects a TLS ClientHello message, such as ClientHello 316, within a SYN packet carrying the PSK extension, then Service Function Forwarder 122 will extract PSK identifier 310 from the SYN packet. The process of identifying the originating SF node corresponding to PSK identifier 310 then proceeds as described above, and Service Function Forwarder 122 then forwards the SYN packet and all subsequent packets in the TCP session to the originating SF node 124 a.

QUIC also supports an initial flight of zero round trip data. QUIC runs over UDP (User Datagram Protocol), and Service Function Forwarder 122 can identify a QUIC packet on a new connection based on the public header fields of the packet. When Service Function Forwarder 122 sees a TLS ClientHello message, such as ClientHello 316, carrying a PSK extension, then Service Function Forwarder 122 will extract PSK identifier 310 from the QUIC packet. The process of identifying the originating SF node corresponding to PSK identifier 310 then proceeds as described above, and Service Function Forwarder 122 then forwards the QUIC packet and all subsequent packets in the QUIC session to the originating SF node 124 a. Unlike TCP, where TLS exchange takes place after the TLS handshake, UDP has no such dependency. Therefore, a Service Function node acting as a QUIC proxy or server in a TLS session would need only to convey the PSK identifier 310 and the corresponding ticket lifetime, using NSH in a new NSH TLV, to the Service Function Forwarder 122. As a QUIC proxy or server, it would not be strictly necessary for a Service Function node to convey the actual PSK itself. In some embodiments, when the QUIC connection is terminated, the Service Function node associated with the QUIC connection can share the information that the QUIC connection is closed by using NSH in a new NSH TLV to Service Function Forwarder 122. On the basis of this received information, Service Function Forwarder 122 can remove the state that it maintains for the now closed QUIC connection. Normally, Service Function Forwarder 122 would not be able to make such a determination, as the “CONNECTION CLOSE” frame used to terminate the QUIC connection is encrypted, and therefore not visible to Service Function Forwarder 122.

While FIG. 3 is directed towards an embodiment in which a resume ClientHello message is forwarded to the same SF node that originated the PSK and handled the previous TLS session, it is also contemplated that a resume ClientHello message can be forwarded to any SF node and the TLS session can be resumed without requiring a full TLS handshake. Accordingly, FIG. 4 depicts a ladder diagram 400 of the underlying message exchange of an example embodiment of the present disclosure, designed to permit a TLS session to be resumed at any SF node without requiring a full TLS handshake. As illustrated, a TLS session is first established between client 102 and SF node 124 a in a manner consistent with the above description of FIGS. 2 and 3.

However, when SF node 124 a transmits PSK identifier 410 to Service Function Forwarder 122, it additionally transmits the PSK itself, using, for example, either the publish-subscribe or NSH encapsulation mechanisms described above. As is illustrated, SF node 124 a may additionally transmit PSK identifier 410 and the PSK itself to additional SF nodes of the same Service Function Group (i.e. SF nodes 124 b and 124 c of Service Function Group 120), prior to or concurrent with the Application Data 412, and before the End Session 414.

Upon receipt of PSK identifier 410 and the PSK, Service Function Forwarder 122 and any SF nodes also receiving the PSK identifier and PSK can construct a database or otherwise store in memory the association between the PSK identifier 410 and the PSK. In some embodiments, the Service Function Forwarder 122 and the SF nodes may each construct a local memory structure for storing the PSK identifier 410 and the PSK. In some embodiments, a single centralized memory structure can be generated for storing the PSK identifier 410 and the PSK, and can be accessed by the Service Function Forwarder 122 and the SF nodes 124 a-c as needed. In either embodiment, the memory structure can be stored in a conventional storage device (e.g. hard drive, solid state drive, etc.) or can be stored in RAM for faster access, and therefore, faster session resumption.

Thus, when client 102 desires to resume the TLS session, it generates a resume ClientHello message 416, which contains the ticket value of NewSessionTicket 208 in the “pre_shared_key” extension (i.e. the PSK identifier 410). If a zero round trip mode is employed, ClientHello 416 can also include an initial flight of data. The resume ClientHello message 416 is then received at Service Function Forwarder 122. In one embodiment, Service Function Forwarder 122 parses the message to extract PSK identifier 410. With the PSK identifier 410 extracted, Service Function Forwarder 122 then consults its database or memory structure (local or centralized) to determine and retrieve the PSK that is associated with PSK identifier 410, and therefore, is associated with the previous TLS session. Service Function Forwarder 122 then selects an SF node to forward the resume ClientHello message 416 to. This selection can be performed based off of various factors for load balancing or otherwise controlling the plurality of SF nodes underneath the control of Service Function Forwarder 122. As illustrated, Service Function Forwarder selects SF node 124 b, and forwards the resume ClientHello message 416 and the PSK that is associated with PSK identifier 410. Consequently, although SF node 124 b did not handle the previous TLS session with client 102, it receives the PSK that was used to encrypt the previous TLS session, and therefore is able to handle the resumed TLS session with client 102.

In another embodiment, Service Function Forwarder may immediately forward resume ClientHello message 416 to a selected SF node, without also including the PSK associated with PSK identifier 410. In this embodiment, SF node 124 b receives the resume ClientHello message 416 and extracts PSK identifier 410. Based upon a determination that PSK identifier 410 was generated by a different SF node, SF node 124 b consults its database or memory structure (local or centralized) to retrieve the PSK associated with the PSK identifier 410. Once the appropriate PSK is retrieved, SF node 124 b is able to handle the resumed TLS session with client 102, even though SF node 124 b did not handle the initial or prior TLS session with client 102.

In either embodiment, no additional TLS handshake is required, and the original PSK used to encrypt the first TLS session is re-used by the new SF node 124 b. In this manner, whenever a new TLS session is established within the Service Function Group 120, the PSK identifier and the associated PSK are circulated and stored such that client 102 can resume its TLS session with any SF node connected to Service Function Forwarder 122. When the ClientHello message 416 includes an initial flight of data, the corresponding ServerHello message 418 can likewise include Application Data, thereby allowing the TLS session to resume immediately (i.e. with zero round trip time). Once resumed, the TLS session may proceed as described previously, with client 102 transmitting a Finished message 420, thereby triggering two way communication of Application Data 422 between client 102 and the new SF node 124 b.

It can be desirable to provide an additional level of security by encrypting the PSK before it is transmitted. FIG. 5 depicts a ladder diagram 500 of the underlying message exchange of an example embodiment of the present disclosure, wherein the transmission of an encrypted PSK and associated decrypting material can permit a TLS session to be resumed at any SF node without requiring a full TLS handshake. As illustrated, a TLS session is first established between client 102 and SF node 124 a in a manner consistent with the above description of FIGS. 2 and 3.

However, rather than transmitting a standard PSK identifier, SF node 124 a instead transmits a PSK identifier that is a self-contained and self-authenticated ticket that can be decrypted to obtain the PSK for the TLS session. In addition to the self-contained and self-authenticated ticket, SF node 124 a additionally transmits cryptographic data 510, comprising a key identifier (e.g. the “key name” value) and the required cryptographic keying material for decrypting the self-contained and self-authenticated ticket. As described previously, the required cryptographic keying material and the key identifier of cryptographic data 510 can be stored in a database or memory structure, either centrally located or localized Similarly, SF node 124 a can transmit the cryptographic data 510 to one or more of Service Function Forwarder 122 and the plurality of SF nodes 124 a-c that are connected to the Service Function Forwarder, prior to or concurrent with the Application Data 512, and before the End Session 514.

Thus, when client 102 desires to resume a TLS session, it generates a resume ClientHello message 516, which contains the self-contained and self-authenticated ticket in the “pre_shared_key” extension. If a zero round trip mode is employed, ClientHello 516 can also include an initial flight of data. The resume ClientHello message 516 is then received at Service Function Forwarder 122, which can perform load balancing or other forwarding logic to select an SF node to forward the resume ClientHello to. As illustrated, the selected node is SF node 124 b. In one embodiment, Service Function Forwarder 122 parses ClientHello message 516 to extract the self-contained and self-authenticated ticket. Service Function Forwarder 122 then consults the database or memory structure to determine and retrieve, based on the key identifier, the required cryptographic keying material for decrypting the self-contained and self-authenticated ticket. Service Function Forwarder 122 then forwards resume ClientHello message 516 and the required cryptographic keying material for decrypting the self-contained and self-authenticated ticket to SF node 124 b. Upon receipt, SF node 124 b extracts the self-contained and self-authenticated ticket from resume ClientHello message 516, and utilizes the required cryptographic keying material received from the Service Function Forwarder 122 to decrypt the self-contained and self-authenticated ticket, thereby obtaining the PSK used to encrypt the previous TLS session between client 102 and SF node 124 a. In this manner, SF node 124 b is able to handle the resume TLS session with client 102, even though SF node 124 b had no previous involvement in the prior TLS session.

In another embodiment, Service Function Forwarder 122 performs load balancing or other forwarding logic and immediately forwards resume ClientHello message 516 to the selected SF node 124 b. Upon receipt, SF node 124 b extracts the self-contained self-authenticated ticket from the PSK identifier of the ClientHello, and consults the database or memory structure to retrieve the required cryptographic keying material, based upon the key identifier. Once retrieved, SF node 124 b uses the required cryptographic keying material to decrypt the self-contained and self-authenticated ticket, thereby obtaining the PSK used to encrypt the previous TLS session between client 102 and SF node 124 a.

In either embodiment, no additional TLS handshake is required, and the TLS session is able to resume quickly and seamlessly because the original PSK used to encrypt the first TLS session is re-used by the new SF node 124 b. In this manner, whenever a new TLS session is established within the Service Function Group 120, the key identifier and required cryptographic keying material of cryptographic data 510 are circulated and stored such that client 102 can resume its TLS session with any SF node connected to Service Function Forwarder 122. When the ClientHello message 516 includes an initial flight of data, the corresponding ServerHello message 518 can likewise include Application Data, thereby allowing the TLS session to resume immediately (i.e. with zero round trip time). Once resumed, the TLS session may proceed as described previously, with client 102 transmitting a Finished message 520, thereby triggering two way communication of Application Data 522 between client 102 and the new SF node 124 b.

In general, methods of the present disclosure bring increased visibility of TLS sessions and their corresponding originating SF node to one or more of the Service Function Forwarder and the plurality of coupled SF nodes. Accordingly, new and improved methods for TLS session resumption are provided, such that the Service Function Forwarder can build and maintain a database or memory structure that tracks the associations between PSKs and their originating SF node. With this information, the Service Function Forwarder is capable of forwarding client resume requests to the same SF node that previously handled the TLS session with the client. Alternatively, the present disclosure also enables a different, new SF node to handle the TLS session resumption without forcing a new TLS handshake, by permitting the new SF node to locate and retrieve the same PSK that was used to encrypt the previous TLS session. In a first approach, the PSK is stored in a database or memory structure along with a corresponding PSK identifier. In a second approach, the PSK is stored in encrypted form in a self-contained and self-authenticating ticket that is transmitted to the new SF node, and the required cryptographic keying material to decrypt and extract the PSK is stored in a database or memory structure. By virtue of the present disclosure, client devices can thus resume TLS sessions at any SF node without having to perform a new TLS handshake, saving time and reducing unnecessary usage of computational resources.

FIG. 6A and FIG. 6B illustrate example system embodiments. The more appropriate embodiment will be apparent to those of ordinary skill in the art when practicing the present technology. Persons of ordinary skill in the art will also readily appreciate that other system embodiments are possible.

FIG. 6A illustrates a conventional system bus computing system architecture 600 wherein the components of the system are in electrical communication with each other using a bus 605. Exemplary system 600 includes a processing unit (CPU or processor) 610 and a system bus 605 that couples various system components including the system memory 615, such as read only memory (ROM) 620 and random access memory (RAM) 625, to the processor 610. The system 600 can include a cache of high-speed memory connected directly with, in close proximity to, or integrated as part of the processor 610. The system 600 can copy data from the memory 615 and/or the storage device 630 to the cache 612 for quick access by the processor 610. In this way, the cache can provide a performance boost that avoids processor 610 delays while waiting for data. These and other modules can control or be configured to control the processor 610 to perform various actions. Other system memory 615 may be available for use as well. The memory 615 can include multiple different types of memory with different performance characteristics. The processor 610 can include any general purpose processor and a hardware module or software module, such as module 1 632, module 2 634, and module 3 636 stored in storage device 630, configured to control the processor 610 as well as a special-purpose processor where software instructions are incorporated into the actual processor design. The processor 610 may essentially be a completely self-contained computing system, containing multiple cores or processors, a bus, memory controller, cache, etc. A multi-core processor may be symmetric or asymmetric.

To enable user interaction with the computing device 600, an input device 645 can represent any number of input mechanisms, such as a microphone for speech, a touch-sensitive screen for gesture or graphical input, keyboard, mouse, motion input, speech and so forth. An output device 635 can also be one or more of a number of output mechanisms known to those of skill in the art. In some instances, multimodal systems can enable a user to provide multiple types of input to communicate with the computing device 600. The communications interface 640 can generally govern and manage the user input and system output. There is no restriction on operating on any particular hardware arrangement and therefore the basic features here may easily be substituted for improved hardware or firmware arrangements as they are developed.

Storage device 630 is a non-volatile memory and can be a hard disk or other types of computer readable media which can store data that are accessible by a computer, such as magnetic cassettes, flash memory cards, solid state memory devices, digital versatile disks, cartridges, random access memories (RAMs) 625, read only memory (ROM) 620, and hybrids thereof.

The storage device 630 can include software modules 632, 634, 636 for controlling the processor 610. Other hardware or software modules are contemplated. The storage device 630 can be connected to the system bus 605. In one aspect, a hardware module that performs a particular function can include the software component stored in a computer-readable medium in connection with the necessary hardware components, such as the processor 610, bus 605, display 635, and so forth, to carry out the function.

FIG. 6B illustrates an example computer system 650 having a chipset architecture that can be used in executing the described method and generating and displaying a graphical user interface (GUI). Computer system 650 is an example of computer hardware, software, and firmware that can be used to implement the disclosed technology. System 650 can include a processor 655, representative of any number of physically and/or logically distinct resources capable of executing software, firmware, and hardware configured to perform identified computations. Processor 655 can communicate with a chipset 660 that can control input to and output from processor 655. In this example, chipset 660 outputs information to output device 665, such as a display, and can read and write information to storage device 670, which can include magnetic media, and solid state media, for example. Chipset 660 can also read data from and write data to RAM 675. A bridge 680 for interfacing with a variety of user interface components 685 can be provided for interfacing with chipset 660. Such user interface components 685 can include a keyboard, a microphone, touch detection and processing circuitry, a pointing device, such as a mouse, and so on. In general, inputs to system 650 can come from any of a variety of sources, machine generated and/or human generated.

Chipset 660 can also interface with one or more communication interfaces 690 that can have different physical interfaces. Such communication interfaces can include interfaces for wired and wireless local area networks, for broadband wireless networks, as well as personal area networks. Some applications of the methods for generating, displaying, and using the GUI disclosed herein can include receiving ordered datasets over the physical interface or be generated by the machine itself by processor 655 analyzing data stored in storage 670 or 675. Further, the machine can receive inputs from a user via user interface components 665 and execute appropriate functions, such as browsing functions by interpreting these inputs using processor 655.

It can be appreciated that example systems 600 and 650 can have more than one processor 610 or be part of a group or cluster of computing devices networked together to provide greater processing capability.

For clarity of explanation, in some instances the present technology may be presented as including individual functional blocks including functional blocks comprising devices, device components, steps or routines in a method embodied in software, or combinations of hardware and software.

In some embodiments the computer-readable storage devices, mediums, and memories can include a cable or wireless signal containing a bit stream and the like. However, when mentioned, non-transitory computer-readable storage media expressly exclude media such as energy, carrier signals, electromagnetic waves, and signals per se.

Methods according to the above-described examples can be implemented using computer-executable instructions that are stored or otherwise available from computer readable media. Such instructions can comprise, for example, instructions and data which cause or otherwise configure a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. Portions of computer resources used can be accessible over a network. The computer executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, firmware, or source code. Examples of computer-readable media that may be used to store instructions, information used, and/or information created during methods according to described examples include magnetic or optical disks, flash memory, USB devices provided with non-volatile memory, networked storage devices, and so on.

Devices implementing methods according to these disclosures can comprise hardware, firmware and/or software, and can take any of a variety of form factors. Typical examples of such form factors include laptops, smart phones, small form factor personal computers, personal digital assistants, rackmount devices, standalone devices, and so on. Functionality described herein also can be embodied in peripherals or add-in cards. Such functionality can also be implemented on a circuit board among different chips or different processes executing in a single device, by way of further example.

The instructions, media for conveying such instructions, computing resources for executing them, and other structures for supporting such computing resources are means for providing the functions described in these disclosures.

Although a variety of examples and other information was used to explain aspects within the scope of the appended claims, no limitation of the claims should be implied based on particular features or arrangements in such examples, as one of ordinary skill would be able to use these examples to derive a wide variety of implementations. Further and although some subject matter may have been described in language specific to examples of structural features and/or method steps, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to these described features or acts. For example, such functionality can be distributed differently or performed in components other than those identified herein. Rather, the described features and steps are disclosed as examples of components of systems and methods within the scope of the appended claims. Moreover, claim language reciting “at least one of” a set indicates that one member of the set or multiple members of the set satisfy the claim. 

What is claimed is:
 1. A method comprising: receiving, at a first Service Function node, a request to establish a Transport Layer Security (TLS) session, where the first Service Function node is one of a plurality of Service Function nodes communicatively coupled to a Service Function Forwarder; generating a Pre-Shared Key (PSK) and a PSK identifier, the PSK and PSK identifier uniquely corresponding to the first Service Function node and the TLS session; forwarding the PSK identifier to one or more of the Service Function Forwarder and the plurality of Service Function nodes; receiving a connection request from the client device, the client device having previously disconnected from the TLS session; determining that the connection request contains the PSK identifier; selecting a second Service Function node and using the PSK to re-establish the TLS session between the client device and the second Service Function node.
 2. The method of claim 1, wherein the second Service Function node is selected by determining the Service Function node uniquely associated with the PSK identifier from the connection request, such that the second Service Function node and the first Service Function node are the same node.
 3. The method of claim 2, wherein the connection request is carried by a Transmission Control Protocol (TCP) SYN packet, such that the second Service Function node determines that the TCP SYN packet contains the PSK identifier, and uses the corresponding PSK to decrypt and process an initial flight of data contained in the TCP SYN packet.
 4. The method of claim 2, wherein the connection request is carried by a Quick UDP Internet Connections (QUIC) packet, such that the second Service Function node determines that the QUIC packet contains the PSK identifier, and uses the corresponding PSK to decrypt and process an initial flight of data contained in the QUIC packet.
 5. The method of claim 1, wherein the second Service Function node is selected by performing load balancing at the Service Function Forwarder, such that the second Service Function node can be any one of the plurality of Service Function nodes.
 6. The method of claim 5, wherein the PSK is stored as an entry in a memory structure and the PSK identifier is a corresponding entry lookup key for the PSK, such that the second Service Function node extracts the PSK identifier from the connection request and obtains the corresponding PSK from the memory structure in order to re-establish the TLS session.
 7. The method of claim 5, wherein the PSK identifier comprises a self-contained ticket containing an encrypted copy of the PSK, and wherein the second Service Function node receives required cryptographic keying material to decrypt the PSK from one or more of the SFF and the plurality of SF nodes, such that the second Service Function node extracts the PSK from the self-contained ticket in order to re-establish the TLS session.
 8. The method of claim 1, wherein forwarding the PSK identifier to one or more of the Service Function Forwarder and the plurality of Service Function nodes comprises a publish-subscribe mechanism.
 9. The method of claim 1, wherein forwarding the PSK identifier to one or more of the Service Function Forwarder and the plurality of Service Function nodes comprises encapsulating the PSK identifier in Network Service Header (NSH) metadata.
 10. The method of claim 9, further comprising using an NSH Metadata-Type 2 Type Length Value (NSH MD-Type 2 TLV) to share the information that a Quick UDP Internet Connections (QUIC) connection has been closed with one or more of the Service Function Forwarder and the plurality of Service Function nodes.
 11. A computer-readable device having stored therein instructions which, when executed by at least one processor, cause the at least one processor to perform operations comprising: receiving, at a first Service Function node, a request to establish a Transport Layer Security (TLS) session, where the first Service Function node is one of a plurality of Service Function nodes communicatively coupled to a Service Function Forwarder; generating a Pre-Shared Key (PSK) and a PSK identifier, the PSK and PSK identifier uniquely corresponding to the first Service Function node and the TLS session; forwarding the PSK identifier to one or more of the Service Function Forwarder and the plurality of Service Function nodes; receiving a connection request from the client device, the client device having previously disconnected from the TLS session; determining that the connection request contains the PSK identifier; selecting a second Service Function node and using the PSK to re-establish the TLS session between the client device and the second Service Function node.
 12. The computer-readable device of claim 11, wherein the instructions further cause the at least one processor to select the second Service Function node by determining the Service Function node uniquely associated with the PSK identifier from the connection request, such that the second Service Function node and the first Service Function node are the same node.
 13. The computer-readable device of claim 12, wherein the connection request is carried by a Transmission Control Protocol (TCP) SYN packet, such that the second Service Function node determines that the TCP SYN packet contains the PSK identifier, and uses the corresponding PSK to decrypt and process an initial flight of data contained in the TCP SYN packet.
 14. The computer-readable device of claim 12, wherein the connection request is carried by a Quick UDP Internet Connections (QUIC) packet, such that the second Service Function node determines that the QUIC packet contains the PSK identifier, and uses the corresponding PSK to decrypt and process an initial flight of data contained in the QUIC packet.
 15. The computer-readable device of claim 11, wherein the instructions further cause the at least one processor to select the second Service Function node by performing load balancing at the Service Function Forwarder, such that the second Service Function node can be any one of the plurality of Service Function nodes.
 16. The computer-readable device of claim 15, wherein the PSK is stored as an entry in a memory structure and the PSK identifier is a corresponding entry lookup key for the PSK, such that the second Service Function node extracts the PSK identifier from the connection request and obtains the corresponding PSK from the memory structure in order to re-establish the TLS session.
 17. The computer-readable device of claim 15, wherein the PSK identifier comprises a self-contained ticket containing an encrypted copy of the PSK, and wherein the second Service Function node receives required cryptographic keying material to decrypt the PSK from one or more of the SFF and the plurality of SF nodes, such that the second Service Function node extracts the PSK from the self-contained ticket in order to re-establish the TLS session.
 18. The computer-readable device of claim 11, wherein the instructions further cause the at least one processor to forward the PSK identifier to one or more of the Service Function Forwarder and the plurality of Service Function nodes with a publish-subscribe mechanism or a modification of Network Service Header (NSH) metadata.
 19. The computer-readable device of claim 11, wherein the instructions further cause the at least one processor to forward the PSK identifier to one or more of the Service Function Forwarder and the plurality of Service Function nodes by encapsulating the PSK identifier in Network Service Header (NSH) metadata.
 20. The computer-readable device of claim 19, wherein the instructions further cause the at least one processor to use an NSH Metadata-Type 2 Type Length Value (NSH MD-Type 2 TLV) to share the information that a Quick UDP Internet Connections (QUIC) connection has been closed with one or more of the Service Function Forwarder and the plurality of Service Function nodes. 